#include "QTimeModel.h"
#include <QPalette>
#include "QTimeView.h"

QTimeModel::QTimeModel(int columnCount, QObject *parent)
    : QAbstractTableModel(parent)
    , _columnCount(columnCount)
{

}

int QTimeModel::rowCount(const QModelIndex &) const
{
    return (_dataList.size() / _columnCount) + (_dataList.size() % _columnCount == 0 ? 0 : 1);
}

int QTimeModel::columnCount(const QModelIndex &) const
{
    return _columnCount;
}

QVariant QTimeModel::data(const QModelIndex &index, int role) const
{
    if (role == Qt::TextAlignmentRole)
        return (int)Qt::AlignCenter;

    switch (role)
    {
    case Qt::DisplayRole: return displayText(index);
    case Qt::TextColorRole: return QColor(30, 30, 30);
    default: return QVariant();
    }
}

Qt::ItemFlags QTimeModel::flags(const QModelIndex &index) const
{
    int value = valueForCell(index.row(), index.column());
    if (value != -1 && (value < _minValue || value > _maxVlaue))
        return Qt::NoItemFlags;
    return QAbstractTableModel::flags(index);
}

int QTimeModel::value() const
{
    return _curValue;
}

void QTimeModel::setValue(int value)
{
    _curValue = value;
    if (_curValue < _minValue)
        _curValue = _minValue;
    else if (_curValue > _maxVlaue)
        _curValue = _maxVlaue;
}

void QTimeModel::setData(const QList<QString>& dataList)
{
    beginResetModel();
    _dataList = dataList;
    endResetModel();
}

int QTimeModel::minValue() const
{
    return _minValue;
}

void QTimeModel::setMinValue(int min)
{
    if (min == _minValue)
        return;
    _minValue = min;
    if (_maxVlaue < _minValue)
        _maxVlaue = _minValue;
    if (_curValue < _minValue)
        _curValue = _minValue;
    internalUpdate();
}

int QTimeModel::maxValue() const
{
    return _maxVlaue;
}

void QTimeModel::setMaxValue(int max)
{
    if (max == _maxVlaue)
        return;
    _maxVlaue = max;
    if (_minValue > _maxVlaue)
        _minValue = _maxVlaue;
    if (_curValue > _maxVlaue)
        _curValue = _maxVlaue;
    internalUpdate();
}

void QTimeModel::cellForValue(int value, int *row, int *column) const
{
    if (!row && !column)
        return;

    if (row) *row = -1;
    if (column) *column = -1;

    for (int i = 0; i < _dataList.size(); i++)
    {
        if (valueNumber(_dataList.at(i)) == value) {
            *column = i % _columnCount;
            *row = i / _columnCount;
            break;
        }
    }
}

int QTimeModel::valueForCell(int row, int column) const
{
    int index = row * _columnCount + column;
    if (index >= 0 && index < _dataList.size()) {
        return valueNumber(_dataList.at(index));
    }
    return -1;
}

QString QTimeModel::displayText(const QModelIndex &index) const
{
    int idx = index.row() * _columnCount + index.column();
    if (idx >= 0 && idx < _dataList.size()) {
        return _dataList.at(idx);
    }
    return QString();
}

void QTimeModel::internalUpdate()
{
    QModelIndex begin = index(0, 0);
    QModelIndex end = index(rowCount() - 1, columnCount() - 1);
    emit dataChanged(begin, end);
}

int QTimeModel::valueNumber(const QString& data) const
{
    QString tmp;
    for (int i = 0; i < data.size(); i++) {
        if (data.at(i) < '0' || data.at(i) > '9')
            break;
        tmp.append(data.at(i));
    }
    return tmp.isEmpty() ? -1 : tmp.toInt();
}
